const Product = require('../models/product');
const User = require('../models/user');
const config = require('../config/config.default');

const productController = {
  // 发布商品
  async createProduct(req, res, next) {
    try {
      const userId = req.user.userId;

      // 检查用户状态
      const user = await User.findById(userId);
      if (!user) {
        return res.status(404).json({
          success: false,
          message: '用户不存在'
        });
      }

      if (user.status !== 'normal') {
        return res.status(403).json({
          success: false,
          message: user.status === 'muted' ? '您已被禁言，无法发布商品' : '账号已被封禁'
        });
      }

      const {
        title,
        description,
        price,
        originalPrice,
        category,
        images,
        condition
      } = req.body;

      // 数据验证
      if (!title || !description || !price || !originalPrice || !category || !condition) {
        return res.status(400).json({
          success: false,
          message: '请填写完整的商品信息'
        });
      }

      // 价格验证
      if (price < 0 || originalPrice < 0) {
        return res.status(400).json({
          success: false,
          message: '价格不能为负数'
        });
      }

      if (price > originalPrice) {
        return res.status(400).json({
          success: false,
          message: '售价不能高于原价'
        });
      }

      // 图片验证和处理
      console.log('接收到的原始数据:', req.body);
      console.log('images类型:', typeof images);
      console.log('images内容:', images);

      if (!images) {
        return res.status(400).json({
          success: false,
          message: '请上传商品图片'
        });
      }

      // 如果images是字符串，尝试解析
      let imagesArray;
      if (typeof images === 'string') {
        try {
          imagesArray = JSON.parse(images);
        } catch (error) {
          console.error('解析图片数据失败:', error);
          return res.status(400).json({
            success: false,
            message: '图片数据格式不正确'
          });
        }
      } else {
        imagesArray = images;
      }

      // 确保imagesArray是数组
      imagesArray = Array.isArray(imagesArray) ? imagesArray : [imagesArray];

      console.log('处理后的图片数组:', imagesArray);

      // 提取图片URL，确保每个元素都有url属性
      const imageUrls = imagesArray.map(img => {
        if (!img || !img.url) {
          throw new Error('图片数据缺少URL');
        }
        return img.url;
      });

      // 创建商品
      const product = new Product({
        title,
        description,
        price: Number(price),
        originalPrice: Number(originalPrice),
        category,
        images: imageUrls,
        condition,
        seller: userId,
        status: '在售'
      });

      // 保存商品到数据库
      await product.save();

      // 返回创建的商品信息
      const populatedProduct = await Product.findById(product._id)
        .populate('seller', 'username email phone');

      res.status(201).json({
        success: true,
        message: '商品发布成功',
        data: { product: populatedProduct }
      });

    } catch (error) {
      console.error('创建商品失败:', error);
      next(error);
    }
  },

  // 获取商品列表
  async getProducts(req, res, next) {
    try {
      const {
        page = 1,
        limit = 10,
        category,
        minPrice,
        maxPrice,
        condition,
        status = '在售'
      } = req.query;

      // 构建查询条件
      const query = { status };
      if (category) query.category = category;
      if (condition) query.condition = condition;
      if (minPrice || maxPrice) {
        query.price = {};
        if (minPrice) query.price.$gte = Number(minPrice);
        if (maxPrice) query.price.$lte = Number(maxPrice);
      }

      // 计算分页
      const skip = (Number(page) - 1) * Number(limit);

      // 查询商品
      const [products, total] = await Promise.all([
        Product.find(query)
          .skip(skip)
          .limit(Number(limit))
          .sort({ createdAt: -1 })
          .populate('seller', 'username avatar'),
        Product.countDocuments(query)
      ]);

      res.json({
        success: true,
        data: {
          products,
          total,
          page: Number(page),
          totalPages: Math.ceil(total / Number(limit))
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取商品详情
  async getProductDetail(req, res, next) {
    try {
      const { id } = req.params;

      const product = await Product.findById(id)
        .populate('seller', 'username avatar studentId');

      if (!product) {
        return res.status(404).json({
          success: false,
          message: '商品不存在'
        });
      }

      res.json({
        success: true,
        data: { product }
      });
    } catch (error) {
      next(error);
    }
  },

  // 更新商品信息（仅允许卖家更新）
  async updateProduct(req, res, next) {
    try {
      const { id } = req.params;
      const userId = req.user.userId;
      const updates = req.body;

      // 查找商品
      const product = await Product.findById(id);
      if (!product) {
        return res.status(404).json({
          success: false,
          message: '商品不存在'
        });
      }

      // 验证是否是卖家
      if (product.seller.toString() !== userId) {
        return res.status(403).json({
          success: false,
          message: '只有卖家可以修改商品信息'
        });
      }

      // 验证商品状态是否允许修改
      if (product.status === '已售出') {
        return res.status(400).json({
          success: false,
          message: '已售出的商品不能修改'
        });
      }

      if (product.status === '交易中' && (updates.price || updates.status)) {
        return res.status(400).json({
          success: false,
          message: '交易中的商品不能修改价格和状态'
        });
      }

      // 允许更新的字段
      const allowedUpdates = [
        'title',
        'description',
        'price',
        'originalPrice',
        'category',
        'condition',
        'images',
        'status'
      ];

      // 过滤不允许的更新字段
      const filteredUpdates = Object.keys(updates)
        .filter(key => allowedUpdates.includes(key))
        .reduce((obj, key) => {
          obj[key] = updates[key];
          return obj;
        }, {});

      // 价格验证
      if (filteredUpdates.price) {
        if (filteredUpdates.price < 0) {
          return res.status(400).json({
            success: false,
            message: '价格不能为负数'
          });
        }
        if (filteredUpdates.originalPrice &&
          filteredUpdates.price > filteredUpdates.originalPrice) {
          return res.status(400).json({
            success: false,
            message: '售价不能高于原价'
          });
        }
      }

      // 更新商品
      const updatedProduct = await Product.findByIdAndUpdate(
        id,
        { $set: filteredUpdates },
        {
          new: true,
          runValidators: true
        }
      ).populate('seller', 'username avatar studentId');

      res.json({
        success: true,
        message: '商品信息更新成功',
        data: { product: updatedProduct }
      });
    } catch (error) {
      next(error);
    }
  },

  // 删除商品
  async deleteProduct(req, res, next) {
    try {
      const { id } = req.params;
      const userId = req.user.userId;

      // 查找商品
      const product = await Product.findById(id);

      if (!product) {
        return res.status(404).json({
          success: false,
          message: '商品不存在'
        });
      }

      // 验证是否是商品发布者
      if (product.seller.toString() !== userId) {
        return res.status(403).json({
          success: false,
          message: '无权删除此商品'
        });
      }

      await Product.findByIdAndDelete(id);

      res.json({
        success: true,
        message: '商品删除成功'
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取商品分类列表
  async getCategories(req, res) {
    try {
      const categories = [
        {
          value: '书籍',
          label: '书籍'
        },
        {
          value: '电子产品',
          label: '电子产品'
        },
        {
          value: '生活用品',
          label: '生活用品'
        },
        {
          value: '服装',
          label: '服装'
        },
        {
          value: '其他',
          label: '其他'
        }
      ];

      res.json({
        success: true,
        data: { categories }
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取商品成色列表
  async getConditions(req, res) {
    try {
      const conditions = [
        {
          value: '全新',
          label: '全新'
        },
        {
          value: '9成新',
          label: '9成新'
        },
        {
          value: '8成新',
          label: '8成新'
        },
        {
          value: '7成新',
          label: '7成新'
        },
        {
          value: '6成新及以下',
          label: '6成新及以下'
        }
      ];

      res.json({
        success: true,
        data: { conditions }
      });
    } catch (error) {
      next(error);
    }
  },

  // 搜索商品
  async searchProducts(req, res, next) {
    try {
      const {
        keyword = '', // 搜索关键词
        category,
        minPrice,
        maxPrice,
        condition,
        sort = 'createdAt',
        order = 'desc',
        page = 1,
        limit = 10
      } = req.query;

      // 构建基础查询条件
      const query = { status: '在售' };

      // 如果有关键词，添加关键词搜索条件
      if (keyword) {
        query.$or = [
          { title: new RegExp(keyword, 'i') },      // 标题匹配
          { description: new RegExp(keyword, 'i') }, // 描述匹配
          { category: new RegExp(keyword, 'i') }     // 分类匹配
        ];
      }

      // 添加其他筛选条件
      if (category) query.category = category;
      if (condition) query.condition = condition;
      if (minPrice || maxPrice) {
        query.price = {};
        if (minPrice) query.price.$gte = Number(minPrice);
        if (maxPrice) query.price.$lte = Number(maxPrice);
      }

      // 构建排序
      const sortOption = {};
      sortOption[sort] = order === 'asc' ? 1 : -1;

      // 计算分页
      const skip = (Number(page) - 1) * Number(limit);

      // 执行查询
      const [products, total] = await Promise.all([
        Product.find(query)
          .skip(skip)
          .limit(Number(limit))
          .sort(sortOption)
          .populate('seller', 'username avatar studentId'),
        Product.countDocuments(query)
      ]);

      res.json({
        success: true,
        data: {
          products,
          total,
          page: Number(page),
          totalPages: Math.ceil(total / Number(limit)),
          query: { keyword, category, minPrice, maxPrice, condition } // 返回搜索条件，方便前端显示
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 获取用户的商品列表
  async getUserProducts(req, res, next) {
    try {
      const userId = req.params.userId || req.user.userId;
      const {
        status,
        category,
        page = 1,
        limit = 10,
        sort = 'createdAt',
        order = 'desc'
      } = req.query;

      // 构建查询条件
      const query = { seller: userId };
      if (status) query.status = status;
      if (category) query.category = category;

      // 构建排序
      const sortOption = {};
      sortOption[sort] = order === 'asc' ? 1 : -1;

      // 计算分页
      const skip = (Number(page) - 1) * Number(limit);

      // 查询商品
      const [products, total] = await Promise.all([
        Product.find(query)
          .skip(skip)
          .limit(Number(limit))
          .sort(sortOption)
          .populate('seller', 'username avatar studentId'),
        Product.countDocuments(query)
      ]);

      // 统计各状态商品数量
      const statusCounts = await Product.aggregate([
        { $match: query },
        {
          $group: {
            _id: '$status',
            count: { $sum: 1 }
          }
        }
      ]);

      res.json({
        success: true,
        data: {
          products,
          total,
          page: Number(page),
          totalPages: Math.ceil(total / Number(limit)),
          statusCounts: statusCounts.reduce((acc, curr) => {
            acc[curr._id] = curr.count;
            return acc;
          }, {})
        }
      });
    } catch (error) {
      next(error);
    }
  }
};

// 管理员商品管理功能
const adminProductMethods = {
  // 管理员获取所有商品列表（包括下架的）
  async getAllProducts(req, res, next) {
    try {
      const {
        page = 1,
        limit = 10,
        status,
        category,
        minPrice,
        maxPrice,
        condition,
        sort = 'createdAt',
        order = 'desc',
        search
      } = req.query;

      // 构建查询条件
      const query = {};
      if (status) query.status = status;
      if (category) query.category = category;
      if (condition) query.condition = condition;
      if (minPrice || maxPrice) {
        query.price = {};
        if (minPrice) query.price.$gte = Number(minPrice);
        if (maxPrice) query.price.$lte = Number(maxPrice);
      }

      // 搜索功能
      if (search) {
        query.$or = [
          { title: new RegExp(search, 'i') },
          { description: new RegExp(search, 'i') }
        ];
      }

      // 构建排序
      const sortOption = {};
      sortOption[sort] = order === 'asc' ? 1 : -1;

      // 计算分页
      const skip = (Number(page) - 1) * Number(limit);

      // 执行查询
      const [products, total] = await Promise.all([
        Product.find(query)
          .skip(skip)
          .limit(Number(limit))
          .sort(sortOption)
          .populate('seller', 'username avatar studentId email phone status'),
        Product.countDocuments(query)
      ]);

      res.json({
        success: true,
        data: {
          products,
          pagination: {
            total,
            page: Number(page),
            limit: Number(limit),
            pages: Math.ceil(total / Number(limit))
          }
        }
      });
    } catch (error) {
      next(error);
    }
  },

  // 管理员下架商品
  async removeProduct(req, res, next) {
    try {
      const { id } = req.params;
      const { reason } = req.body;

      const product = await Product.findById(id);
      if (!product) {
        return res.status(404).json({
          success: false,
          message: '商品不存在'
        });
      }

      // 检查商品是否已经下架
      if (product.status === '已下架') {
        return res.status(400).json({
          success: false,
          message: '商品已经是下架状态'
        });
      }

      // 更新商品状态为已下架
      product.status = '已下架';
      product.adminRemark = reason || '管理员下架';
      product.updatedAt = new Date();
      product.updatedBy = req.user.userId;

      await product.save();

      // 通知卖家
      // 这里可以添加通知逻辑，如发送系统消息或邮件

      res.json({
        success: true,
        message: '商品已成功下架',
        data: { product }
      });
    } catch (error) {
      next(error);
    }
  },

  // 管理员商品审核
  async reviewProduct(req, res, next) {
    try {
      const { id } = req.params;
      const { status, reason } = req.body;

      if (!['在售', '已下架'].includes(status)) {
        return res.status(400).json({
          success: false,
          message: '无效的商品状态'
        });
      }

      const product = await Product.findById(id);
      if (!product) {
        return res.status(404).json({
          success: false,
          message: '商品不存在'
        });
      }

      // 更新商品状态
      product.status = status;
      product.adminRemark = reason || (status === '在售' ? '管理员审核通过' : '管理员下架');
      product.updatedAt = new Date();
      product.updatedBy = req.user.userId;

      await product.save();

      res.json({
        success: true,
        message: status === '在售' ? '商品已审核通过' : '商品已下架',
        data: { product }
      });
    } catch (error) {
      next(error);
    }
  },

  // 管理员获取商品详情
  async getProductAdmin(req, res, next) {
    try {
      const { id } = req.params;

      const product = await Product.findById(id)
        .populate('seller', 'username avatar studentId email phone status')
        .populate('updatedBy', 'username');

      if (!product) {
        return res.status(404).json({
          success: false,
          message: '商品不存在'
        });
      }

      res.json({
        success: true,
        data: { product }
      });
    } catch (error) {
      next(error);
    }
  }
};

// 合并所有方法
module.exports = {
  ...productController,
  ...adminProductMethods
}; 